home *** CD-ROM | disk | FTP | other *** search
/ Gigarom 1 / Gigarom Macintosh Archives (Quantum Leap)(CDRM1080320)(1993).iso / FILES / DEV / A-B / add images.cpt / HandleTheMenus.c < prev    next >
Text File  |  1989-06-22  |  10KB  |  432 lines
  1. /* =======================================
  2.  
  3. File: HandleTheMenus.c
  4. Function: Handle any menu selections.
  5. History:    4/27/89 Original by Prototyper.
  6.             4/27/89 modified by c. keith ray
  7.  
  8. ====================================== */
  9.  
  10. #include "HandleTheMenus.h"
  11.  
  12. /* *********************************** */
  13. /* These are the other includes for general routines */
  14. /* #include <colortoolbox.h> */
  15. #include <Strings.h>
  16. #include <IM1_5Protos.h> /* includes every-mac-thing that THINK has defined */
  17. #include "color_transfer_modes.h"
  18.  
  19. extern char *strcpy (Str255 *, char *);    /* LSC string prototype */
  20.  
  21. /* *********************************** */
  22.  
  23. #define      TRUE   1
  24. #define      FALSE  0
  25. #define      NIL    0
  26.  
  27. #define ABS(x) ( (x) < 0 ? -(x) : (x) )
  28.  
  29. /* *********************************** */
  30.  
  31. /* External routines that are called */
  32.  
  33. #include "about_alert.h"
  34. #include "Source_2.h"
  35. #include "Source_1.h"
  36. #include "Result.h"
  37.  
  38. extern WindowPtr Result_Window;
  39. extern WindowPtr proton_Window;
  40. extern WindowPtr flourine_Window;
  41.  
  42. extern MenuHandle AppleMenu;
  43. extern MenuHandle FileMenu;
  44. extern MenuHandle EditMenu;
  45. extern MenuHandle ModeMenu;
  46.  
  47. extern short pix_zoom;
  48. extern short clipboard_empty;
  49. extern short add_mode;
  50. extern short src_changed;
  51.  
  52. /* menus-lists and menu-items that change depending on window, zoom, or clipboard */
  53. /* Item_Open_Pict  */
  54. /* Item_Close        */
  55. /* Item_Save_Pict  */
  56. /* Item_Magnify    */
  57. /* Item_Reduce     */
  58. /* Item_Undo         */
  59. /* Item_Cut        */
  60. /* Item_Copy       */
  61. /* Item_Paste      */
  62. /* Item_Clear      */
  63. /* Item_Select_All */
  64. /* Item_Crop       */
  65. /* List_Mode         */
  66.  
  67. void Update_Menus( tempWindow )
  68.     WindowPtr tempWindow;
  69. {
  70.     if ( tempWindow != NIL )
  71.     /* test if no windows in front - which should be impossible for this program */
  72.     {
  73.         if ( tempWindow == proton_Window )
  74.         {
  75.             EnableItem( FileMenu, Item_Open_Pict );
  76.             DisableItem( FileMenu, Item_Close );
  77.             DisableItem( FileMenu, Item_Save_Pict );
  78.             if ( pix_zoom == 1 )
  79.             {
  80.                 EnableItem (FileMenu, Item_Magnify);
  81.                 DisableItem (FileMenu, Item_Reduce); /* disable reduce menu */
  82.  
  83.             }
  84.             else if (pix_zoom == 8)
  85.             {
  86.                 DisableItem (FileMenu, Item_Magnify); /* disable magnify menu */
  87.                 EnableItem (FileMenu, Item_Reduce);
  88.             }
  89.             else
  90.             {
  91.                 EnableItem (FileMenu, Item_Magnify); /* enable magnify menu */
  92.                 EnableItem (FileMenu, Item_Reduce);
  93.             }
  94.             DisableItem(EditMenu, Item_Undo);
  95.             DisableItem(EditMenu, Item_Cut);
  96.             DisableItem(EditMenu, Item_Copy);
  97.             if ( clipboard_empty == TRUE )
  98.             {
  99.                 DisableItem(EditMenu, Item_Paste);
  100.             }
  101.             else
  102.             {
  103.                 EnableItem(EditMenu, Item_Paste);
  104.             }
  105.             EnableItem(EditMenu, Item_Crop);
  106.             EnableItem( ModeMenu , 0);
  107.         }
  108.         else if ( tempWindow == flourine_Window )
  109.         {
  110.             EnableItem( FileMenu, Item_Open_Pict );
  111.             DisableItem( FileMenu, Item_Close );
  112.             DisableItem( FileMenu, Item_Save_Pict );
  113.             if ( pix_zoom == 1 )
  114.             {
  115.                 EnableItem (FileMenu, Item_Magnify);
  116.                 DisableItem (FileMenu, Item_Reduce); /* disable reduce menu */
  117.  
  118.             }
  119.             else if (pix_zoom == 8)
  120.             {
  121.                 DisableItem (FileMenu, Item_Magnify); /* disable magnify menu */
  122.                 EnableItem (FileMenu, Item_Reduce);
  123.             }
  124.             else
  125.             {
  126.                 EnableItem (FileMenu, Item_Magnify); /* enable magnify menu */
  127.                 EnableItem (FileMenu, Item_Reduce);
  128.             }
  129.             DisableItem(EditMenu, Item_Undo);
  130.             DisableItem(EditMenu, Item_Cut);
  131.             DisableItem(EditMenu, Item_Copy);
  132.             if ( clipboard_empty == TRUE )
  133.             {
  134.                 DisableItem(EditMenu, Item_Paste);
  135.             }
  136.             else
  137.             {
  138.                 EnableItem(EditMenu, Item_Paste);
  139.             }
  140.             EnableItem(EditMenu, Item_Crop);
  141.             EnableItem( ModeMenu , 0);
  142.         }
  143.         else if ( tempWindow == Result_Window )
  144.         {
  145.             DisableItem( FileMenu, Item_Open_Pict );
  146.             DisableItem( FileMenu, Item_Close );
  147.             EnableItem( FileMenu, Item_Save_Pict );
  148.             if ( pix_zoom == 1 )
  149.             {
  150.                 EnableItem (FileMenu, Item_Magnify);
  151.                 DisableItem (FileMenu, Item_Reduce); /* disable reduce menu */
  152.  
  153.             }
  154.             else if (pix_zoom == 8)
  155.             {
  156.                 DisableItem (FileMenu, Item_Magnify); /* disable magnify menu */
  157.                 EnableItem (FileMenu, Item_Reduce);
  158.             }
  159.             else
  160.             {
  161.                 EnableItem (FileMenu, Item_Magnify); /* enable magnify menu */
  162.                 EnableItem (FileMenu, Item_Reduce);
  163.             }
  164.             DisableItem(EditMenu, Item_Undo);
  165.             EnableItem(EditMenu, Item_Cut);
  166.             EnableItem(EditMenu, Item_Copy);
  167.             DisableItem(EditMenu, Item_Paste);
  168.             EnableItem(EditMenu, Item_Crop);
  169.             EnableItem( ModeMenu , 0);
  170.         }
  171.         else /* desk accessory in front */
  172.         {
  173.             DisableItem( FileMenu, Item_Open_Pict );
  174.             EnableItem( FileMenu, Item_Close );
  175.             DisableItem( FileMenu, Item_Save_Pict );
  176.  
  177.             DisableItem (FileMenu, Item_Magnify);
  178.             DisableItem (FileMenu, Item_Reduce); /* disable reduce menu */
  179.  
  180.             EnableItem(EditMenu, Item_Undo);
  181.             EnableItem(EditMenu, Item_Cut);
  182.             EnableItem(EditMenu, Item_Copy);
  183.             if ( clipboard_empty == TRUE )
  184.             {
  185.                 DisableItem(EditMenu, Item_Paste);
  186.             }
  187.             else
  188.             {
  189.                 EnableItem(EditMenu, Item_Paste);
  190.             }
  191.             DisableItem(EditMenu, Item_Crop);
  192.             DisableItem( ModeMenu , 0);
  193.         }
  194.     }
  195. }
  196.  
  197. void HandleMenu (doneFlag, theMenu, theItem, theInput)
  198.     char *doneFlag;
  199.     short theMenu, theItem;
  200.     TEHandle *theInput;
  201. {
  202.     GrafPtr SavePort;
  203.     Str255 DAName;
  204.     short DNA;                /* DA selection ID */
  205.     char BoolHolder;        /* Boolean used in handling edit commands */
  206.  
  207.     WindowPeek da_window;
  208.     
  209.     switch (theMenu)
  210.     {
  211.  
  212.     case List_Apple:
  213.         switch (theItem)
  214.         {
  215.         case Item_About_Add_Images:
  216.             A_about_alert ();
  217.             break;
  218.         default:            /* Handle the DAs */
  219.             GetPort (&SavePort);
  220.             GetItem (AppleMenu, theItem, (char *)&DAName);
  221.             DNA = OpenDeskAcc ((char *)&DAName);
  222.             SetPort (SavePort);
  223.             break;
  224.         }
  225.         break;
  226.  
  227.  
  228.     case List_File:
  229.         switch (theItem)
  230.         {
  231.         case Item_Open_Pict:
  232.             /* ?? ADD IN HERE WHAT THIS ITEM SHOULD DO
  233.                 -- check to see if proton or flourine is on top
  234.                 -- if one of them is, then My_Read_Image() for that window
  235.             */
  236.             if ( FrontWindow() == flourine_Window )
  237.             {
  238.                 read_flourine();
  239.             }
  240.             else if ( FrontWindow() == proton_Window )
  241.             {
  242.                 read_proton();
  243.             }
  244.             break;
  245.         case Item_Close: /* assume that update_menus etc. prevents us from trying to close normal windows */
  246.             da_window =  (WindowPeek) ( FrontWindow() );
  247.             CloseDeskAcc ( (*da_window).windowKind);
  248.             break;
  249.         case Item_Save_Pict:
  250.             /* ?? ADD IN HERE WHAT THIS ITEM SHOULD DO
  251.                 -- check to see if Result is on top, if it is,
  252.                 -- then My_Write_Image()
  253.             */
  254.             save_result();
  255.             break;
  256.         case Item_Magnify:
  257.               pix_zoom *= 2; /* multiply zoom factor by 2 */
  258.               UpDate_Result(Result_Window);      /* force redraw at new magnification */
  259.               UpDate_proton(proton_Window); 
  260.               UpDate_flourine(flourine_Window); 
  261.             break;
  262.         case Item_Reduce:
  263.             pix_zoom /= 2; /* divide zoom factor by 2 */
  264.             UpDate_Result(Result_Window);      /* force redraw at new magnification */
  265.             UpDate_proton(proton_Window);
  266.             UpDate_flourine(flourine_Window);
  267.             break;
  268.         case Item_Quit:
  269.             *doneFlag = TRUE;    /* Set exit the program flag */
  270.             break;
  271.         default:
  272.             break;
  273.  
  274.         }
  275.         break;
  276.  
  277.  
  278.     case List_Edit:
  279.         BoolHolder = SystemEdit (theItem - 1);    /* Do DA editing */
  280.         if (BoolHolder == FALSE)    /* If not a DA then we get it */
  281.         {
  282.             switch (theItem)
  283.             {
  284.             case Item_Undo:
  285.  
  286.                 break;
  287.             case Item_Cut:
  288.                 if ( FrontWindow() == Result_Window )
  289.                 {
  290.                     cut_result();
  291.                 }
  292.                 break;
  293.             case Item_Copy:
  294.                 if ( FrontWindow() == Result_Window )
  295.                 {
  296.                     copy_result();
  297.                 }
  298.                 break;
  299.             case Item_Paste:
  300.                 if ( FrontWindow() == proton_Window )
  301.                 {
  302.                     paste_proton();
  303.                 }
  304.                 else if ( FrontWindow() == flourine_Window )
  305.                 {
  306.                     paste_flourine();
  307.                 }
  308.                 break;
  309.             case Item_Clear:
  310.                 if ( FrontWindow() == Result_Window )
  311.                 {
  312.                     /* clear both source images */
  313.                     clear_flourine();
  314.                     clear_proton();
  315.                     clear_result();
  316.                     
  317.                 }
  318.                 else if ( FrontWindow() == proton_Window )
  319.                 {
  320.                     /* clear source 1 image */
  321.                     clear_proton();
  322.                 }
  323.                 else if ( FrontWindow() == flourine_Window )
  324.                 {
  325.                     /* clear souce 2 image */
  326.                     clear_flourine();
  327.                 }
  328.                 break;
  329.             case Item_Select_All:
  330.                 break;
  331.             case Item_Crop:
  332.                 /*
  333.                     this is supposed to trim the result & source images to be the
  334.                     size of the window's displayable area.
  335.                 */
  336.                 break;
  337.             default:
  338.                 break;
  339.  
  340.             }
  341.         }
  342.         break;
  343.  
  344.  
  345.     case List_Mode:
  346.         do_checkmark( ModeMenu, theItem, Item_Add_Over, Item_Exclusive_Or_Invert);
  347.         switch (theItem)
  348.         {
  349.             case Item_Add_Over:
  350.                 add_mode = addOver;
  351.                 break;
  352.             case Item_Add_Pin:
  353.                 add_mode = addPin;
  354.                 break;
  355.             case Item_Sub_Over:
  356.                 add_mode = subOver;
  357.                 break;
  358.             case Item_Sub_Pin:
  359.                 add_mode = subPin;
  360.                 break;
  361.             case Item_Maximum:
  362.                 add_mode = adMax;
  363.                 break;
  364.             case Item_Minimum:
  365.                 add_mode = adMin;
  366.                 break;
  367.             case Item_Blend:
  368.                 add_mode = blend;
  369.                 break;
  370.             case Item_Transparent:
  371.                 add_mode = transparent;
  372.                 break;
  373.             case Item_Copy_Mode:
  374.                 add_mode = srcCopy;
  375.                 break;
  376.             case Item_Copy_Invert:
  377.                 add_mode = notSrcCopy;
  378.                 break;
  379.             case Item_Or:
  380.                 add_mode = srcOr;
  381.                 break;
  382.             case Item_Or_Invert:
  383.                 add_mode = notSrcOr;
  384.                 break;
  385.             case Item_Change_Black:
  386.                 add_mode = srcBic;
  387.                 break;
  388.             case Item_Change_Black_Invert:
  389.                 add_mode = notSrcBic;
  390.                 break;
  391.             case Item_Exclusive_Or:
  392.                 add_mode = srcXor;
  393.                 break;
  394.             case Item_Exclusive_Or_Invert:
  395.                 add_mode = notSrcXor;
  396.                 break;
  397.             default:
  398.                 break;
  399.         }
  400.         src_changed = TRUE;  /* force updating the contents of the result window */
  401.         UpDate_Result(Result_Window);
  402.         break;
  403.  
  404.     default:
  405.         break;
  406.  
  407.     }
  408.  
  409.     HiliteMenu (0);            /* Turn menu selection off*/
  410. }
  411.  
  412.  
  413.  
  414. void do_checkmark( menuh, item, groupstart, groupend)
  415.     MenuHandle menuh;
  416.     short item, groupstart, groupend;
  417. /* a utility-function to handle a check-mark-group in any menu */
  418. {
  419.     short i;
  420.     for (i = groupstart; i < groupend; i++)
  421.     {
  422.         if ( i == item)
  423.         {
  424.             CheckItem(menuh, i, true);
  425.         }
  426.         else
  427.         {
  428.             CheckItem(menuh, i, false);
  429.         }
  430.     }
  431. }
  432.